Nanodegree key: nd213
Version: 1.0.0
Locale: en-us
Content
Part 01 : Welcome
-
Module 01: Orientation
-
Lesson 01: Welcome to the C++ Developer Nanodegree Program
- Concept 01: Intro
- Concept 02: Prerequisites
- Concept 03: Courses
- Concept 04: Projects
- Concept 05: David Silver
- Concept 06: Stephen Welch
- Concept 07: Ermin Kreponic
- Concept 08: Andreas Haja
- Concept 09: Bjarne Stroustrup
- Concept 10: What It Takes
- Concept 11: Reviews
- Concept 12: Knowledge
- Concept 13: Student Hub
-
Lesson 02: Introduction to C++
C++ is one of the most important programming languages in the world. It is particularly important for high-performance software.
-
Lesson 03: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.
-
-
Module 02: How to Get Help from Peers and Mentors
-
Lesson 01: Welcome to Udacity
You are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
-
Lesson 02: Get Help with Your Account
What to do if you have questions about your account or general questions about the program.
-
Part 02 : Foundations
-
Module 01: Foundations
-
Lesson 02: Introduction to the C++ Language
- Concept 01: Intro
- Concept 02: CODE: Write and Run Your First C++ Program
- Concept 03: Compiled Languages vs Scripted Languages
- Concept 04: C++ Output and Language Basics
- Concept 05: CODE: Send Output to the Console
- Concept 06: How to Store Data
- Concept 07: Bjarne Introduces C++ Types
- Concept 08: Primitive Variable Types
- Concept 09: What is a Vector?
- Concept 10: C++ Vectors
- Concept 11: C++ Comments
- Concept 12: Using Auto
- Concept 13: CODE: Store a Grid in Your Program
- Concept 14: Getting Ready for Printing
- Concept 15: Working with Vectors
- Concept 16: For Loops
- Concept 17: Functions
- Concept 18: CODE: Print the Board
- Concept 19: If Statements and While Loops
- Concept 20: Reading from a File
- Concept 21: CODE: Read the Board from a File
- Concept 22: Processing Strings
- Concept 23: Adding Data to a Vector
- Concept 24: CODE: Parse Lines from the File
- Concept 25: CODE: Use the ParseLine Function
- Concept 26: Formatting the Printed Board
- Concept 27: CODE: Formatting the Printed Board
- Concept 28: CODE: Store the Board using the State Enum
- Concept 29: Great Work!
-
Lesson 03: A* Search
- Concept 01: Intro
- Concept 02: Motion Planning
- Concept 03: Maze
- Concept 04: Maze 2
- Concept 05: Coding the Shortest Path Algorithm
- Concept 06: A* Search
- Concept 07: Lesson Code Structure
- Concept 08: CODE: Starting A* Search
- Concept 09: CODE: Writing the A* Heuristic
- Concept 10: Pass by Reference in C++
- Concept 11: CODE: Adding Nodes to the Open Vector
- Concept 12: CODE: Initialize the Open Vector
- Concept 13: CODE: Create a Comparison Function
- Concept 14: CODE: Write a While Loop for the A* Algorithm
- Concept 15: CODE: Check for Valid Neighbors
- Concept 16: Constants
- Concept 17: CODE: Expand the A* Search to Neighbors
- Concept 18: Arrays
- Concept 19: CODE: Adding a Start and End to the Board
- Concept 20: Congratulations!!
- Concept 21: How to Become More Proficient at C++
-
Lesson 04: Writing Larger Programs
- Concept 01: Intro
- Concept 02: Header Files
- Concept 03: Using Multiple Files
- Concept 04: Bjarne on Build Systems
- Concept 05: CMake and Make
- Concept 06: References
- Concept 07: Pointers
- Concept 08: Pointers Continued
- Concept 09: References vs Pointers
- Concept 10: Classes and Object-Oriented Programming
- Concept 11: Classes and OOP Continued
- Concept 12: Outro
-
Lesson 05: Extending the OpenStreetMap Data Model
- Concept 01: Intro
- Concept 02: The OpenStreetMap Project
- Concept 03: IO2D Starter Code
- Concept 04: CODE: Building, Running, and Testing
- Concept 05: Upcoming Exercise and Project Format
- Concept 06: CODE: The RouteModel Class
- Concept 07: CODE: The Node Class
- Concept 08: This Pointer
- Concept 09: CODE: Create RouteModel Nodes
- Concept 10: CODE: Write the Distance Function
- Concept 11: What Are the Most Important Containers to Learn?
- Concept 12: Hash Tables
- Concept 13: CODE: Create Node to Road Hash Table
- Concept 14: CODE: Write FindNeighbor
- Concept 15: CODE: Write FindNeighbors
- Concept 16: CODE: Find the Closest Node
- Concept 17: Outro
-
Lesson 06: A* with OpenStreetMap Data
- Concept 01: Intro
- Concept 02: How Long Does it Take to Learn C++?
- Concept 03: CODE: The RoutePlanner Header
- Concept 04: CODE: The RoutePlanner Constructor
- Concept 05: CODE: Construct the Final Path
- Concept 06: CODE: Write the A* Search Stub
- Concept 07: CODE: Calculate H Values
- Concept 08: CODE: Get the Next Node
- Concept 09: CODE: Add New Neighbors
- Concept 10: CODE: Complete A* Search
- Concept 11: CODE: Add User Input
- Concept 12: Outro
Part 03 : Object-Oriented Programming
-
Module 01: Object-Oriented Programming
-
Lesson 02: Intro to OOP
In this lesson, you will explore some of the basic object oriented functionality of the C++ language.
- Concept 01: Classes and OOP
- Concept 02: Bjarne On Classes In C++
- Concept 03: Jupyter Notebooks
- Concept 04: Structures
- Concept 05: Member Initialization
- Concept 06: Access Specifiers
- Concept 07: Classes
- Concept 08: Encapsulation and Abstraction
- Concept 09: Bjarne on Encapsulation
- Concept 10: Constructors
- Concept 11: Scope Resolution
- Concept 12: Initializer Lists
- Concept 13: Initializing Constant Members
- Concept 14: Encapsulation
- Concept 15: Accessor Functions
- Concept 16: Mutator Functions
- Concept 17: Quiz: Classes in C++
- Concept 18: Exercise: Pyramid Class
- Concept 19: Exercise: Student Class
- Concept 20: Encapsulation in C++
- Concept 21: Bjarne On Abstraction
- Concept 22: Abstraction
- Concept 23: Exercise: Sphere Class
- Concept 24: Exercise: Private Method
- Concept 25: Exercise: Static Members
- Concept 26: Exercise: Static Methods
- Concept 27: Bjarne On Solving Problems
-
Lesson 03: Advanced OOP
In this lesson, we'll get into some of the more advanced topics in object oriented programming, including inheritance, polymorphism and templates.
- Concept 01: Polymorphism and Inheritance
- Concept 02: Bjarne on Inheritance
- Concept 03: Inheritance
- Concept 04: Access Specifiers
- Concept 05: Exercise: Animal Class
- Concept 06: Exercise: Composition
- Concept 07: Exercise: Multiple Inheritance
- Concept 08: Exercise: Class Hierarchy
- Concept 09: Exercise: Friends
- Concept 10: Polymorphism: Overloading
- Concept 11: Exercise: Operator Overload
- Concept 12: Polymorphism: Overriding
- Concept 13: Exercise: Virtual Functions
- Concept 14: Exercise: Override
- Concept 15: Generic Programming
- Concept 16: Bjarne on Generic Programming
- Concept 17: Templates
- Concept 18: Bjarne on Templates
- Concept 19: Exercise: Comparison Operation
- Concept 20: Exercise: Deduction
- Concept 21: Exercise: Class Template
- Concept 22: Uninitialized Members
- Concept 23: Summary
- Concept 24: Bjarne on Best Practices with Classes
-
Lesson 04: Project: System Monitor
Time to build the project! In this lesson, you'll get the tools you need to build the project for this course, a system monitor application similar to htop!
- Concept 01: Introduction
- Concept 02: Project Overview
- Concept 03: Project Objectives
- Concept 04: Project File Structure
- Concept 05: Cloud Workspace Intro
- Concept 06: Project Workspace
- Concept 07: constants.h
- Concept 08: util.h
- Concept 09: ProcessParser.h
- Concept 10: RAM Usage
- Concept 11: CPU Usage
- Concept 12: Process Up Time
- Concept 13: System Up Time
- Concept 14: Process User
- Concept 15: PID List
- Concept 16: Get Command
- Concept 17: Number of Cores
- Concept 18: System CPU Percent
- Concept 19: CPU Stats
- Concept 20: RAM Percent
- Concept 21: System Info
- Concept 22: Process Class
- Concept 23: Process Container
- Concept 24: Display Info
- Concept 25: Congratulations!
- Concept 26: Bonus: ncurses Introduction
- Concept 27: Bonus: ncurses Basic Setup
- Concept 28: Bonus: ncurses Print and Modify
- Concept 29: Bonus Exercise: ncurses Windowing Part 1
- Concept 30: Bonus Exercise: ncurses Windowing Part 2
- Concept 31: Bonus: ncurses Windowing Part 1
- Concept 32: Bonus: Ncurses Windowing Part 2
-
Lesson 05: Coming Soon: Updated System Monitor Project
Time to build the project! In this lesson, you'll get the tools you need to build the project for this course, a system monitor application similar to htop!
- Concept 01: Introduction
- Concept 02: htop
- Concept 03: Starter Code
- Concept 04: Goal
- Concept 05: Project Structure
- Concept 06: Build Tools
- Concept 07: System Class
- Concept 08: System Data
- Concept 09: LinuxParser Namespace
- Concept 10: String Parsing
- Concept 11: Processor Class
- Concept 12: Processor Data
- Concept 13: Process Class
- Concept 14: Process Data
Part 04 : Memory Management
-
Module 01: Memory Management
-
Lesson 01: Introduction
Learn about stack and heap in C++, get ready for memory management in C++!
-
Lesson 02: Pointers and References
Learn about pointers, the primitive data type for store, manipulation and initialization of memory and memory addresses in C++.
- Concept 01: Introduction to Pointers
- Concept 02: Bjarne on pointers
- Concept 03: Pointers Example
- Concept 04: Pointers Exercise 1
- Concept 05: Pointers Exercise 2
- Concept 06: Pointers Exercise 3
- Concept 07: Pointers Exercise 4
- Concept 08: Pointers Project Lab
- Concept 09: Introduction to References
- Concept 10: Bjarne on References
- Concept 11: References Example
- Concept 12: References Exercise 1
- Concept 13: References Exercise 2
-
Lesson 03: new and delete
Learn about memory allocation in C++, which is technique of memory management where programs and services are assigned to use host computer memory!
- Concept 01: Introduction
- Concept 02: Bjarne on new and delete
- Concept 03: new
- Concept 04: new - Example
- Concept 05: delete
- Concept 06: delete - Example
- Concept 07: new and delete Exercise 1
- Concept 08: new and delete Exercise 2
- Concept 09: new and delete Exercise 3
- Concept 10: new and delete Project Exercise
- Concept 11: Bjarne on Memory Leaks
- Concept 12: memset and malloc
- Concept 13: memset
- Concept 14: memset - Example
- Concept 15: malloc
- Concept 16: malloc - Example
-
Lesson 04: Smart Pointers
Learn about smart pointers, designed in C++ to improve native safety and performance of memory management of this language.
- Concept 01: Bjarne on Smart Pointer
- Concept 02: Bjarne on Pointer Best Practices
- Concept 03: Smart Pointers
- Concept 04: Smart Pointer Exercise 1
- Concept 05: Smart Pointer Exercise 2
- Concept 06: Resource Scope
- Concept 07: Bjarne on Scope
- Concept 08: Resource Scope Exercise 1
- Concept 09: Resource Scope Exercise 2
- Concept 10: Bjarne on Importance of Scope
-
Lesson 05: Garbage Collector
Implement your own smart pointer with garbage collection functionality and master memory management in C++!
- Concept 01: Project Introduction
- Concept 02: Project Overview
- Concept 03: Pointer Lab
- Concept 04: Reference Lab
- Concept 05: "New" and "Delete" Lab
- Concept 06: Smart Pointer Explanation
- Concept 07: Smart Pointer Lab
- Concept 08: Resource Scope Lab
- Concept 09: Garbage Collector: TODO
- Concept 10: Project Workspace
-
Part 05 : Concurrency
-
Module 01: Concurrency
-
Lesson 01: Introduction and Running Threads
Learn the difference between processes and threads, and write your own concurrent program running multiple threads at the same time.
-
Lesson 02: Passing Data Between Threads
Learn to use promises and futures to create safe communication between threads. Also learn about tasks as an alternative to threads. Finally, understand data races and how to avoid them.
-
Lesson 03: Mutexes and Locks
Use mutexes and locks to safely access shared data from various threads.
-
Lesson 04: Condition Variables and Message Queues
Use condition variables as a basic synchronization tool between threads. Understand and implement a concurrent message queue for flexible inter-thread communication
-
Lesson 05: Program a Concurrent Traffic Simulation
Build a multithreaded traffic simulator using a real urban map. Run each vehicle on a separate thread, and manage intersections to facilitate traffic flow and avoid collisions.
Project Description - Program a Concurrent Traffic Simulation
-
Part 06 : Career Services
These Career Services will ensure you make meaningful connections with industry professionals to accelerate your career growth - whether looking for a job or opportunities to collaborate with your peers. Unlike your Nanodegree projects, you do not need to meet specifications on these Services to progress in your program. Submit these Career Services once, and get honest, personalized feedback and next steps from Udacity Career Coaches!
-
Module 01: Career Services
-
Lesson 01: Industry Research
You're building your online presence. Now learn how to share your story, understand the tech landscape better, and meet industry professionals.
- Concept 01: Self-Reflection: Design Your Blueprint for Success
- Concept 02: Debrief: Self-Reflection Exercise Part 1
- Concept 03: Debrief: Self-Reflection Exercise Part 2
- Concept 04: Map Your Career Journey
- Concept 05: Debrief: Map Your Career Journey
- Concept 06: Conduct an Informational Interview
- Concept 07: How to Request an Informational Interview
- Concept 08: Ways to Connect
- Concept 09: Ask Good Questions
- Concept 10: Debrief: Sample Questions Quiz
- Concept 11: Keep the Conversation Going
-
Lesson 02: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
- Concept 01: Prove Your Skills With GitHub
- Concept 02: Introduction
- Concept 03: GitHub profile important items
- Concept 04: Good GitHub repository
- Concept 05: Interview with Art - Part 1
- Concept 06: Identify fixes for example “bad” profile
- Concept 07: Quick Fixes #1
- Concept 08: Quick Fixes #2
- Concept 09: Writing READMEs with Walter
- Concept 10: Interview with Art - Part 2
- Concept 11: Commit messages best practices
- Concept 12: Reflect on your commit messages
- Concept 13: Participating in open source projects
- Concept 14: Interview with Art - Part 3
- Concept 15: Participating in open source projects 2
- Concept 16: Starring interesting repositories
- Concept 17: Next Steps
-
Lesson 03: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
- Concept 01: Get Opportunities with LinkedIn
- Concept 02: Use Your Story to Stand Out
- Concept 03: Why Use an Elevator Pitch
- Concept 04: Create Your Elevator Pitch
- Concept 05: Use Your Elevator Pitch on LinkedIn
- Concept 06: Create Your Profile With SEO In Mind
- Concept 07: Profile Essentials
- Concept 08: Work Experiences & Accomplishments
- Concept 09: Build and Strengthen Your Network
- Concept 10: Reaching Out on LinkedIn
- Concept 11: Boost Your Visibility
- Concept 12: Up Next
-
Part 07 : Capstone
-
Module 01: Capstone
-
Lesson 01: Capstone
In this lesson, you will build your own C++ application, following the principles you have learned throughout this Nanodegree Program.
-